home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 402_01 / cforms-2.2 / src / output.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-20  |  9.9 KB  |  403 lines
  1. /*******************************************************************************
  2.  *
  3.  *        O U T P U T . C
  4.  *        ---------------
  5.  *
  6.  * Description:
  7.  *    Generates the C-code for CForms.
  8.  *
  9.  * Included functions:
  10.  *    output        - Does the job
  11.  *
  12.  * Revision:
  13.  *    Ver    Date    By        Reason
  14.  *    ---    ----    --        ------
  15.  *    1.00    900627    Lars Berntzon    Created
  16.  *
  17.  ******************************************************************************/
  18. #ifndef lint
  19. static volatile char sccs_id[] = "@(#) output.c,v 1.14 1993/07/20 23:58:14 lasse Exp";
  20. #endif
  21.  
  22. #include "config.h"
  23. #include "token.h"
  24. #include "comp.h"
  25. #include "../patchlevel.h"
  26.  
  27. static char module[200];
  28. static char ofname[202];
  29.  
  30. /******************************************************************
  31.  *        O U T P U T
  32.  *        -----------
  33.  * Description:
  34.  *    Write out the file.
  35.  *
  36.  * Arguments:
  37.  *    none
  38.  *
  39.  * Return:
  40.  *    none
  41.  *
  42.  * Global variables:
  43.  *    filename    - Name of input file.
  44.  *    list        - Struct of lists of all things.
  45.  *
  46.  ******************************************************************/
  47. void output(void)
  48. {
  49.     struct picture *pp;
  50.     struct field *fp;
  51.     struct event *ep;
  52.     struct stmt *sp;
  53.     struct literal *lp;
  54.     struct ccode *cp;
  55.     int n_fields, n_events, n_literals, n_pictures;
  56.     FILE *out;
  57.     char *p;
  58.  
  59.     /*
  60.      * Make module name.
  61.      */
  62.     if ((p = strrchr(filename, '/')) != NULL) p++;
  63.     else p = filename;
  64.  
  65.     strncpy(module, p, sizeof module);
  66.     if (p = strrchr(module, '.'))
  67.     {
  68.     *p = 0;
  69.     }
  70.  
  71.     /*
  72.      * Make output filename.
  73.      */
  74.     strncpy(ofname, filename, sizeof ofname);
  75.     if ((p = strrchr(ofname, '.')) != NULL) *p = 0;
  76.     strcat(ofname, ".c");
  77.     
  78.     /*
  79.      * Open output file.
  80.      */
  81.     if ((out = fopen(ofname, "w")) == NULL)
  82.     {
  83.         fprintf(stderr, "failed to open output file.\n");
  84.         cleanup(0);
  85.     }
  86.     
  87.     /*
  88.      * G e n e r a t e   H e a d e r.
  89.      */
  90.      
  91.      fprintf(out, "/* Generated by C-Forms version %s */\n\n", PATCHLEVEL);
  92.      fprintf(out, "#include <stdio.h>\n\n");
  93.      fprintf(out, "#include <curses.h>\n");
  94.      fprintf(out, "#include <cforms.h>\n\n");
  95.  
  96.     /* 
  97.      * D e c l a r a t i o n   o f   t h i s   m o d u l e.
  98.      */
  99.     fprintf(out, "extern struct module _cf_module_%s;\n\n", module);
  100.     
  101.     /*
  102.      * C r e a t e   C - c o d e s.
  103.      */
  104.     debug("writing c-codes...");
  105.     if (list.ccode) fprintf(out, "    /* C - c o d e s */\n");
  106.     for(cp = list.ccode; cp != NULL; cp = NEXT_CCODE(cp)) 
  107.     {
  108.     stmt_write(cp->stmt, out);
  109.     fprintf(out, "\n\n");
  110.     }
  111.     
  112.     /*
  113.      * C r e a t e   p i c t u r e s.
  114.      */
  115.     debug("writing pictures...");
  116.     if (list.picture) fprintf(out, "    /* P i c t u r e s */\n\n");
  117.     for(pp = list.picture; pp != NULL; pp = NEXT_PICTURE(pp))
  118.     {
  119.     /*
  120.      * E v e n t s   f o r   a l l   f i e l d s.
  121.      */
  122.     n_fields = 0;
  123.     n_literals = 0;
  124.     debug("writing events for fields...");    
  125.     for(fp = pp->field; fp != NULL; fp = NEXT_FIELD(fp))
  126.     {
  127.         /* Event routines for field */
  128.         
  129.         for(ep = fp->event; ep != NULL; ep = NEXT_EVENT(ep))
  130.         {
  131.         if (ep->stmt) {
  132.             fprintf(out, "static void event_%s_%s_%s(int event_code)\n{\n",
  133.             pp->link.name, fp->link.name, ep->link.name);
  134.             stmt_write(ep->stmt, out);
  135.             fprintf(out, "\n}\n");
  136.         }
  137.         }
  138.         
  139.         /* Event table for field */
  140.  
  141.         if (fp->event) {
  142.         fprintf(out, "static struct event etab_%s_%s[] = {\n",
  143.             pp->link.name, fp->link.name);
  144.         for(ep = fp->event; ep != NULL; ep = NEXT_EVENT(ep))
  145.         {
  146.             fprintf(out, "    %s, %s, %d, ", ep->type, ep->code, ep->global);
  147.             
  148.             if (ep->stmt) {
  149.             fprintf(out, "event_%s_%s_%s",
  150.                 pp->link.name, fp->link.name, ep->link.name);
  151.             }
  152.             else {
  153.             fprintf(out, "NULL");
  154.             }
  155.             fprintf(out, "%s\n", NEXT_EVENT(ep) ? "," : "");
  156.         }
  157.         fprintf(out, "};\n\n");
  158.         }
  159.         
  160.         /* 
  161.          * F i e l d   d a t a   a r r a y.
  162.          */
  163.         if (fp->value) {
  164.         fprintf(out, "static char field_%s_%s[%d] = \"%s\";\n\n",
  165.             pp->link.name, fp->link.name, fp->len + 1, fp->value);
  166.         }
  167.         else {
  168.         fprintf(out, "static char field_%s_%s[%d];\n\n",
  169.             pp->link.name, fp->link.name, fp->len + 1);
  170.         }
  171.         fprintf(out, "/***************************************************/\n");
  172.     }
  173.     
  174.     /*
  175.      * T a b l e   o f   a l l   f i e l d s.
  176.      */
  177.     debug("writing table of fields...");
  178.     if (pp->field) {
  179.         fprintf(out, "static struct field ftab_%s[] = {\n", pp->link.name);
  180.         
  181.         for(fp = pp->field; fp != NULL; n_fields++, fp = NEXT_FIELD(fp))
  182.         {
  183.         fprintf(out, "   {\"%s\", ", fp->link.name);
  184.         fprintf(out, "%s, %d, ", fp->type, fp->len);
  185.         fprintf(out, "field_%s_%s, ", pp->link.name, fp->link.name);
  186.  
  187.         /* 
  188.          * Calculated centered field.
  189.          */
  190.         if (ISCENTER(fp->pos.x)) {
  191.             fprintf(out, "%d, ",
  192.             fp->pos.x - CF_CENTER + pp->viewport->size.x / 2 -
  193.             fp->len / 2);
  194.         }
  195.         else if (ISMAX(fp->pos.x)) {
  196.             fprintf(out, "%d, ",
  197.             fp->pos.x - CF_MAX + pp->viewport->size.x - 1 -
  198.             fp->len);
  199.         }
  200.         else {
  201.             fprintf(out, "%d, ", fp->pos.x);
  202.         }
  203.  
  204.         if (ISCENTER(fp->pos.y)) {
  205.             fprintf(out, "%d, ",
  206.             fp->pos.y - CF_CENTER + pp->viewport->size.y / 2);
  207.         }
  208.         else if (ISMAX(fp->pos.y)) {
  209.             fprintf(out, "%d, ",
  210.             fp->pos.y - CF_MAX + pp->viewport->size.y - 1);
  211.         }
  212.         else {
  213.             fprintf(out, "%d, ", fp->pos.y);
  214.         }
  215.  
  216.         fprintf(out, "\"%s\", \"%s\", ",
  217.             fp->lvalue ? fp->lvalue : "", fp->rvalue ? fp->rvalue : "");
  218.  
  219.         if (fp->event) {
  220.             fprintf(out, "etab_%s_%s", pp->link.name, fp->link.name);
  221.         }
  222.         else {
  223.             fprintf(out, "NULL");
  224.         }
  225.         for(n_events = 0, ep = fp->event; ep != NULL;
  226.             n_events++, ep = NEXT_EVENT(ep))
  227.             ;
  228.         fprintf(out, ", %d, %d", n_events, fp->flags);
  229.         fprintf(out, ", 0"); /* Modified flag */
  230.         fprintf(out, ", NULL"); /* Modified flag */
  231.         fprintf(out, "}%s", NEXT_FIELD(fp) ? ",\n" : "\n");
  232.         }
  233.         fprintf(out, "};\n\n");
  234.     }
  235.     
  236.     /*
  237.      * T a b l e   o f   l i t e r a l s.
  238.      */
  239.     debug("writing table of literals...");
  240.     if (pp->literal) {
  241.         fprintf(out, "static struct literal ltab_%s[] = {\n", pp->link.name);
  242.         for(lp = pp->literal; lp != NULL; n_literals++, lp = NEXT_LITERAL(lp))
  243.         {
  244.         if (ISCENTER(lp->pos.x)) {
  245.             fprintf(out, "    %d, ",
  246.             lp->pos.x - CF_CENTER + pp->viewport->size.x / 2 -
  247.             (int)strlen(lp->link.name) / 2);
  248.         }
  249.         else if (ISMAX(lp->pos.x)) {
  250.             fprintf(out, "    %d, ",
  251.             lp->pos.x - CF_MAX + pp->viewport->size.x - 1 -
  252.             strlen(lp->link.name));
  253.         }
  254.         else {
  255.             fprintf(out, "    %d, ", lp->pos.x);
  256.         }
  257.  
  258.         if (ISCENTER(lp->pos.y)) {
  259.             fprintf(out, "%d, ",
  260.             lp->pos.y - CF_CENTER + pp->viewport->size.y / 2);
  261.         }
  262.         else if (ISMAX(lp->pos.y)) {
  263.             fprintf(out, "%d, ",
  264.             lp->pos.y - CF_MAX + pp->viewport->size.y - 1);
  265.         }
  266.         else {
  267.             fprintf(out, "%d, ", lp->pos.y);
  268.         }
  269.  
  270.         fprintf(out, "\"%s\", %d%s\n",
  271.             lp->link.name, lp->flags,
  272.             NEXT_LITERAL(lp) ? "," : "");
  273.         }
  274.         fprintf(out, "};\n\n");
  275.     }
  276.     
  277.     /*
  278.      * E v e n t s   f o r   p i c t u r e.
  279.      */
  280.     debug("writing events for pictures...");
  281.     for(ep = pp->event; ep != NULL; ep = NEXT_EVENT(ep))
  282.     {
  283.         if (ep->stmt) {
  284.         fprintf(out, "static void event_%s_%s(int event_code)\n{\n",
  285.             pp->link.name, ep->link.name);
  286.         stmt_write(ep->stmt, out);
  287.         fprintf(out, "\n}\n\n");
  288.         }
  289.     }
  290.     
  291.     n_events = 0;
  292.     if(pp->event) {
  293.         fprintf(out, "static struct event etab_%s[] = {\n", 
  294.         pp->link.name);
  295.         for(ep = pp->event; ep != NULL; n_events++, ep = NEXT_EVENT(ep))
  296.         {
  297.         fprintf(out, "    %s, %s, %d, ", ep->type, ep->code, ep->global);
  298.         
  299.         if (ep->stmt) {
  300.             fprintf(out, "event_%s_%s", pp->link.name, ep->link.name);
  301.         }
  302.         else {
  303.             fprintf(out, "NULL");
  304.         }
  305.         fprintf(out, "%s\n", NEXT_EVENT(ep) ? "," : "");
  306.         }
  307.         fprintf(out, "};\n\n");
  308.     }
  309.     }
  310.     
  311.     /*
  312.      * T a b l e   o f   p i c t u r e s.
  313.      */
  314.     debug("writing table of pictures...");
  315.     if(list.picture) {
  316.         fprintf(out, "static struct picture ptab[] = {\n");
  317.     }
  318.     n_pictures = 0;
  319.     for(pp = list.picture; pp != NULL; n_pictures++, pp = NEXT_PICTURE(pp))
  320.     {
  321.         fprintf(out, "    {\"%s\", ", pp->link.name);
  322.             /* Fields */
  323.     for(n_fields = 0, fp = pp->field; fp; fp = NEXT_FIELD(fp)) {
  324.         n_fields++;
  325.     }
  326.     
  327.     if (pp->field) {
  328.         fprintf(out, "ftab_%s, %d, ", pp->link.name, n_fields);
  329.     }
  330.     else fprintf(out, "NULL, 0, ");
  331.     
  332.         /* Literals */
  333.     for(n_literals = 0, lp = pp->literal; lp; lp = NEXT_LITERAL(lp)) {
  334.         n_literals++;
  335.     }
  336.     if (pp->literal) {
  337.         fprintf(out, "ltab_%s, %d, ", pp->link.name, n_literals);
  338.     }
  339.     else fprintf(out, "NULL, 0, ");
  340.     
  341.         /* Events */
  342.     for(n_events = 0, ep = pp->event; ep; ep = NEXT_EVENT(ep)) {
  343.         n_events++;
  344.     }
  345.     if (pp->event) {
  346.         fprintf(out, "etab_%s, %d", pp->link.name, n_events);
  347.     }
  348.     else fprintf(out, "NULL, 0");
  349.  
  350.     fprintf(out, ", %d,%d, %d,%d", pp->viewport->pos.x,pp->viewport->pos.y,
  351.         pp->viewport->size.x, pp->viewport->size.y);
  352.  
  353.     fprintf(out, ", &_cf_module_%s, ", module);
  354.     fprintf(out, "%d}", pp->flags);
  355.  
  356.     if (NEXT_PICTURE(pp)) {
  357.         fprintf(out, ",");
  358.     }
  359.     fprintf(out, "\n");
  360.     }
  361.     if(list.picture) {
  362.         fprintf(out, "};\n\n");
  363.     }
  364.  
  365.     /*
  366.      * Event functions for module.
  367.      */
  368.     debug("writing events for module...");
  369.     for(ep = list.event; ep != NULL; ep = NEXT_EVENT(ep))
  370.     {
  371.         if (ep->stmt) {
  372.         fprintf(out, "static void event_%s(int event_code)\n{\n", ep->link.name);
  373.         stmt_write(ep->stmt, out);
  374.         fprintf(out, "\n}\n\n");
  375.     }
  376.     }
  377.     n_events = 0;
  378.     if(list.event) {
  379.         fprintf(out, "static struct event etab[] = {\n");
  380.         for(ep = list.event; ep != NULL; n_events++, ep = NEXT_EVENT(ep))
  381.         {
  382.             fprintf(out, "    %s, %s, %d, ", ep->type, ep->code, ep->global);
  383.             
  384.             if (ep->stmt) {
  385.                 fprintf(out, "event_%s", ep->link.name);
  386.             }
  387.             else {
  388.                 fprintf(out, "NULL");
  389.             }
  390.             fprintf(out, "%s\n", NEXT_EVENT(ep) ? "," : "");
  391.         }
  392.         fprintf(out, "};\n\n");
  393.     }
  394.  
  395.     debug("writing module...");
  396.     fprintf(out, "struct module _cf_module_%s = { ", module);
  397.     if (list.picture) fprintf(out, "ptab, %d, ", n_pictures);
  398.     else fprintf(out, "NULL, 0, ");
  399.     if (list.event)  fprintf(out, "etab, %d", n_events);
  400.     else fprintf(out, "NULL, 0");
  401.     fprintf(out, "};\n");
  402. }
  403.